package com.smart.community.property.utils;

import com.smart.community.property.event.PermissionChangeEvent;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Component;

import java.util.List;

/**
 * 权限缓存管理工具类
 * 提供便捷的权限缓存刷新方法
 * @author Wu.Liang
 * @since 2025-06-29
 */
@Slf4j
@Component
public class PermissionCacheUtils {

    private static ApplicationEventPublisher eventPublisher;

    @Autowired
    public void setEventPublisher(ApplicationEventPublisher eventPublisher) {
        PermissionCacheUtils.eventPublisher = eventPublisher;
    }

    /**
     * 刷新用户权限缓存
     * @param userId 用户ID
     */
    public static void refreshUserPermissionCache(Long userId) {
        if (userId == null) {
            log.warn("用户ID为空，跳过权限缓存刷新");
            return;
        }

        log.debug("触发用户权限缓存刷新事件，用户ID: {}", userId);
        
        if (eventPublisher != null) {
            eventPublisher.publishEvent(PermissionChangeEvent.userPermissionChange(userId));
        }
    }

    /**
     * 批量刷新用户权限缓存
     * @param userIds 用户ID列表
     */
    public static void refreshUserPermissionCacheBatch(List<Long> userIds) {
        if (userIds == null || userIds.isEmpty()) {
            log.warn("用户ID列表为空，跳过批量权限缓存刷新");
            return;
        }

        log.debug("批量触发用户权限缓存刷新事件，用户数量: {}", userIds.size());
        
        for (Long userId : userIds) {
            if (userId != null) {
                eventPublisher.publishEvent(PermissionChangeEvent.userPermissionChange(userId));
            }
        }
    }

    /**
     * 刷新角色权限缓存
     * @param roleId 角色ID
     */
    public static void refreshRolePermissionCache(Long roleId) {
        if (roleId == null) {
            log.warn("角色ID为空，跳过权限缓存刷新");
            return;
        }

        log.debug("触发角色权限缓存刷新事件，角色ID: {}", roleId);
        
        if (eventPublisher != null) {
            eventPublisher.publishEvent(PermissionChangeEvent.rolePermissionChange(roleId));
        }
    }

    /**
     * 批量刷新角色权限缓存
     * @param roleIds 角色ID列表
     */
    public static void refreshRolePermissionCacheBatch(List<Long> roleIds) {
        if (roleIds == null || roleIds.isEmpty()) {
            log.warn("角色ID列表为空，跳过批量权限缓存刷新");
            return;
        }

        log.debug("批量触发角色权限缓存刷新事件，角色数量: {}", roleIds.size());
        
        for (Long roleId : roleIds) {
            if (roleId != null) {
                eventPublisher.publishEvent(PermissionChangeEvent.rolePermissionChange(roleId));
            }
        }
    }

    /**
     * 刷新社区权限缓存
     * @param communityId 社区ID
     */
    public static void refreshCommunityPermissionCache(Long communityId) {
        if (communityId == null) {
            log.warn("社区ID为空，跳过权限缓存刷新");
            return;
        }

        log.debug("触发社区权限缓存刷新事件，社区ID: {}", communityId);
        
        if (eventPublisher != null) {
            eventPublisher.publishEvent(PermissionChangeEvent.communityChange(communityId));
        }
    }

    /**
     * 刷新物业公司权限缓存
     * @param propertyCompanyId 物业公司ID
     */
    public static void refreshPropertyCompanyPermissionCache(Long propertyCompanyId) {
        if (propertyCompanyId == null) {
            log.warn("物业公司ID为空，跳过权限缓存刷新");
            return;
        }

        log.debug("触发物业公司权限缓存刷新事件，物业公司ID: {}", propertyCompanyId);
        
        if (eventPublisher != null) {
            eventPublisher.publishEvent(PermissionChangeEvent.propertyCompanyChange(propertyCompanyId));
        }
    }

    /**
     * 刷新所有权限缓存
     */
    public static void refreshAllPermissionCache() {
        log.debug("触发所有权限缓存刷新事件");
        
        if (eventPublisher != null) {
            eventPublisher.publishEvent(PermissionChangeEvent.allPermissionChange());
        }
    }
}
